from django.shortcuts import render,redirect,HttpResponse
from app01 import models
from app01.utils.encrypt import md5
#靓号管理：使用ModelForm
from django import forms
from django.core.validators import RegexValidator
from django.core.exceptions import ValidationError
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.views.decorators.csrf import csrf_exempt  #Ajax使用POST时免除csrf校验
from datetime import datetime
import random
 

# Create your views here.
def depart_list(request):
    # 部门列表：取数据库数据，取到的是queryset类型，可以看做是一个对象列表，[对象,对象，对象]，每个对象是一行数据
    queryset=models.Department.objects.all()
    return render (request,"depart_list.html",{"queryset":queryset})
def depart_add(request):
    if request.method=="GET":
        return render(request,"depart_add.html")
    title=request.POST.get("title")
    models.Department.objects.create(title=title)
    return redirect("/depart/list/")
def depart_delete(request):
    nid=request.GET.get('nid')
    models.Department.objects.filter(id=nid).delete()
    return redirect("/depart/list/")
def depart_edit(request,nid):
    # nid= request.GET.get('nid')
    if request.method=="GET":
        row_obj=models.Department.objects.filter(id=nid).first()
        return render(request,"depart_edit.html",{"row_obj":row_obj})
    title=request.POST.get("title")
    models.Department.objects.filter(id=nid).update(title=title)
    return redirect("/depart/list/")

def user_list(request):
    # 用户列表：取数据库数据，取到的是queryset类型，可以看做是一个对象列表，[对象,对象，对象]，每个对象是一行数据
    queryset=models.UserInfo.objects.all()
    for obj in queryset:
        create_time=obj.create_time.strftime("%y-%m-%d")
        depart=obj.depart.title
        gender=obj.get_gender_display()
        print(create_time,depart,gender)
    return render (request,"user_list.html",{"queryset":queryset})

def user_add(request):
    if request.method=="GET":
        context={
            "gender_choices":models.UserInfo.gender_choices,
            "depart_list":models.Department.objects.all(),
        }
        return render(request,"user_add.html",context)
    
    name=request.POST.get("name")
    password=request.POST.get("password")
    age=request.POST.get("age")
    account=request.POST.get("account")
    create_time=request.POST.get("create_time")
    depart_id=request.POST.get("depart_id")
    gender=request.POST.get("gender")

    models.UserInfo.objects.create(name=name,password=password,age=age,account=account,create_time=create_time,depart_id=depart_id,gender=gender)
    return redirect("/user/list/")


# 使用Modelform 进行添加，编辑

class UserModelForm(forms.ModelForm):
    class Meta:
        model=models.UserInfo
        fields=["name","password","age","account","create_time","depart","gender"]        
        # widgets={
        #     # "name":forms.TextInput(attrs={"class":"form-control"}),
        #     "password":forms.PasswordInput(attrs={"class":"form-control", "placeholder":"密码"}),
        #     # "age":forms.TextInput(attrs={"class":"form-control"})
        # }
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            # if name=="password":
            #     continue
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}

def user_model_form_add(request):
    if request.method=="GET":
        form=UserModelForm()
        return render (request, "user_model_form_add.html",{"form":form})
    #處理POST數據：
    form = UserModelForm(data=request.POST) 
    if form.is_valid():
        form.save()
        return redirect ("/user/list")
    else:
        # print(form.errors)
        return render (request, "user_model_form_add.html",{"form":form})

    
def user_edit(request,nid):
    row_obj=models.UserInfo.objects.filter(id=nid).first()
    if request.method=="GET":        
        form=UserModelForm(instance=row_obj)
        return render(request,"user_edit.html",{"form":form})
    #處理POST數據：
    
    form = UserModelForm(data=request.POST,instance=row_obj) 
    if form.is_valid():
        form.save()
        return redirect ("/user/list")
    else:
        # print(form.errors)
        return render (request, "user_edit.html",{"form":form})

def user_delete(request):
    nid=request.GET.get('nid')
    models.UserInfo.objects.filter(id=nid).delete()
    return redirect("/user/list/")


#NumAddModelForm用于靓号添加only
class NumAddModelForm(forms.ModelForm):
    #添加额外的字段验证，可以对一个字段进行多种验证方式用逗号隔开
    mobile=forms.CharField(
        label="手机号",
        validators=[RegexValidator(r'^1[3-9]\d{9}$','手机号要以1开头，3~9是第二位，总共11位')],
          )
    class Meta:
        model=models.PrettyNum
        #要使用的字段定义：有以下三种情况的写法，可以是某些，可以是全部，也可以是排除某个
        fields=["mobile","price","level","status"] 
        # fields="__all__"       #显示所有字段
        # exclude='level'   #只排除某个字段
    #为解决对应Html中class属性缺失问题，在此用插件的形式进行定义：
        # widgets={
        #     #mobile字段我没有尝试成功，不知道什么原因？？？？？
        #     "mobile":forms.TextInput(attrs={"class":"form-control"}), 
        #     "price":forms.TextInput(attrs={"class":"form-control"}), 
        # }
    #为解决对应Html中class属性缺失问题，这是老师总结的另一种方式的定义，来代替上面的插件定义方法：
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            #可以对某个字段进行特殊定义
            # if name=="password":
            #     continue
            #下面是循环方式定义了所有插件的class属性
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}
    #字段额外验证方法二：钩子方法
    def clean_mobile(self):    #clean开头，后面跟已经定义的字段名
        text_mobile=self.cleaned_data["mobile"]   #text_mobile是输入的字段内容
        #定义验证方法：看手机号是否已经存在于数据库中，如果已存在，返回错误，校验通过，返回输入值 
        # 注意：下面的校验显然不适用于编辑，因为编辑时该数据本身肯定是已经存在于数据库中了，必须换一种方法，不包括自己才行       
        exists = models.PrettyNum.objects.filter(mobile=text_mobile).exists() #exists=True,or False
        if exists:
            raise ValidationError("手机号已存在！")
        return text_mobile  #如果exists=False，代表手机号不存在
def num_list(request):    #显示list是不需要modelform的，Modelform往往用于某一行数据的操作 
    #实现显示list的搜索功能，如果有搜索内容时，通过get方法传过来q的值  
    data_dict={}    
    value=request.GET.get('q','')  #获取q值，如果没有值，则value获取到的是空值
    if value:  #获取到值了，value值添加进字典，没有值，value为空
        data_dict["mobile__contains"]=value 
    queryset=models.PrettyNum.objects.filter(**data_dict).order_by("-level")   #前面的"-"加与不加时代表desc/asc

    #------添加分页：   
    per_page = 8     # 每页显示数量    
    paginator = Paginator(queryset, per_page)    # 创建Paginator对象    
    page_number = request.GET.get('page', 1)    # 获取当前页码（从GET参数获取，默认第1页）
    try:       
        queryset = paginator.page(page_number)   # 获取当前页对象
    except PageNotAnInteger:       
        queryset = paginator.page(1)  # 如果页码不是整数，返回第一页
    except EmptyPage:       
        queryset = paginator.page(paginator.num_pages)  # 如果页码超出范围，返回最后一页
    #------添加分页时，下面return中添加 'paginator': paginator

    return render (request,"num_list.html",{"queryset":queryset,'paginator': paginator,"value":value})  #把value也传过去，确保搜索值一直可显示
 
def num_add(request):
    if request.method=="GET":
        form=NumAddModelForm()
        return render (request, "num_add.html",{"form":form})
    #處理POST數據：
    form = NumAddModelForm(data=request.POST) 
    if form.is_valid():
        form.save()
        return redirect ("/num/list")
    else:
        # print(form.errors)
        return render (request, "num_add.html",{"form":form})

#NumAddModelForm用于靓号编辑only
class NumEditModelForm(forms.ModelForm):
    #单独设置mobile列显示但不可以改，如果不想显示，可以直接在下面fields中去掉就可以了
    # mobile = forms.CharField(disabled=True,label="手机号")
    class Meta:
        model=models.PrettyNum
        fields=["mobile","price","level","status"] 
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items(): 
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}
    #字段额外验证方法二：钩子方法
    def clean_mobile(self):    #clean开头，后面跟已经定义的字段名
        text_mobile=self.cleaned_data["mobile"]   #text_mobile是输入的字段内容
        #定义验证方法，如果总长度不是11位，返回错误，校验通过，返回输入值
        #同时加入了手机号是否已存在的判断，self.instance.pk返回当前行的id,判断是否重复时要把自己这行数据排除
        exists = models.PrettyNum.objects.filter(mobile=text_mobile).exclude(id=self.instance.pk).exists()
        if len(text_mobile) !=11 or exists:  #要用or
            raise ValidationError("格式错误或手机号重复！")
            
        return text_mobile

def num_edit(request,nid):
    row_obj=models.PrettyNum.objects.filter(id=nid).first()
    if request.method=="GET":        
        form=NumEditModelForm(instance=row_obj)
        return render(request,"num_edit.html",{"form":form})
    #處理POST數據：
    
    form = NumEditModelForm(data=request.POST,instance=row_obj) 
    if form.is_valid():
        form.save()
        return redirect ("/num/list")
    else:
        # print(form.errors)
        return render (request, "num_edit.html",{"form":form})
def num_delete(request):
    nid=request.GET.get('nid')
    models.PrettyNum.objects.filter(id=nid).delete()
    return redirect("/num/list/")

 
class AdminAddModelForm(forms.ModelForm):
    #自定义一个确认密码的字段，widget定义使得密码显示为星号
    confirm_password = forms.CharField(label="确认密码",widget=forms.PasswordInput)
    class Meta:        
        model=models.Admin
        fields=["username","password","confirm_password"] 
        #为了显示为**，将password字段做下面定义
        widgets={
            "password": forms.PasswordInput
        }

    #为解决对应Html中class属性缺失问题，这是老师总结的另一种方式的定义，来代替上面的插件定义方法：
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            #可以对某个字段进行特殊定义
            # if name=="password":
            #     continue
            #下面是循环方式定义了所有插件的class属性
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}
    #字段额外验证方法二：钩子方法
    def clean_username(self):    #clean开头，后面跟已经定义的字段名
        text_username=self.cleaned_data["username"]   #text_mobile是输入的字段内容
        #定义验证方法：看手机号是否已经存在于数据库中，如果已存在，返回错误，校验通过，返回输入值 
        # 注意：下面的校验显然不适用于编辑，因为编辑时该数据本身肯定是已经存在于数据库中了，必须换一种方法，不包括自己才行       
        exists = models.Admin.objects.filter(username=text_username).exists() #exists=True,or False
        if exists:
            raise ValidationError("用户已存在！")
        return text_username  #如果exists=False，代表手机号不存在
    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        return md5(pwd)  #返回的是加了密的密码
    #用钩子函数的方式，来实现密码两次输入一致性的验证
    def clean_confirm_password(self):    #clean开头，后面跟已经定义的字段名
        pwd=self.cleaned_data["password"]    #cleaned_data包含了所有的提交字段的值
        confirm=md5(self.cleaned_data["confirm_password"]) #对confirm_password也进行加密
        if confirm !=pwd: #比较的是加密后的密码
            raise ValidationError("密码不一致！")
        return confirm   # return 什么，则confirm_password这个字段的值就保存什么
def admin_list(request):   
    #实现显示list的搜索功能，如果有搜索内容时，通过get方法传过来q的值  
    data_dict={}    
    value=request.GET.get('q','')  #获取q值，如果没有值，则value获取到的是空值
    if value:  #获取到值了，value值添加进字典，没有值，value为空
        data_dict["username__contains"]=value 
    queryset=models.Admin.objects.filter(**data_dict).order_by("id")   #前面的"-"加与不加时代表desc/asc
    return render (request,"admin_list.html",{"queryset":queryset,"value":value})  #把value也传过去，确保搜索值一直可显示 

def admin_add(request):
    if request.method=="GET":
        form=AdminAddModelForm()
        return render (request, "admin_add.html",{"form":form})
    #處理POST數據：
    form = AdminAddModelForm(data=request.POST) 
    if form.is_valid():
        form.save()
        return redirect ("/admin/list")
    else:
        return render (request, "admin_add.html",{"form":form})
#用于Admin编辑only
class AdminEditModelForm(forms.ModelForm):
    #自定义一个确认密码的字段，widget定义使得密码显示为星号
    confirm_password = forms.CharField(label="确认密码",widget=forms.PasswordInput)
    class Meta:        
        model=models.Admin
        fields=["username","password","confirm_password"] 
        #添加时为了显示为**，将password字段做下面定义，但是编辑时不能保留，如果保留则密码显示未空，估计是因为这样定义就只能是输入框
        #编辑时还是要保留，这样编辑时的密码就是空的，和新建一样，只是验证后不能和原密码相同
        widgets={
            "password": forms.PasswordInput
        }

    #为解决对应Html中class属性缺失问题，这是老师总结的另一种方式的定义，来代替上面的插件定义方法：
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            #可以对某个字段进行特殊定义
            # if name=="password":
            #     continue
            #下面是循环方式定义了所有插件的class属性
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}

    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        #验证重新输入的密码是否和之前密码相同
        md5_pwd=md5(pwd)       
        exists = models.Admin.objects.filter(id=self.instance.pk, password=md5_pwd).exists()
        print("应在编辑后提交时显示：",pwd,exists)
        if exists:
            raise ValidationError("密码不能和之前相同！")
        return md5_pwd  #返回的是加了密的密码
    #用钩子函数的方式，来实现密码两次输入一致性的验证
    def clean_confirm_password(self):    #clean开头，后面跟已经定义的字段名
        pwd=self.cleaned_data.get("password")    #cleaned_data包含了所有的提交字段的值
        confirm=md5(self.cleaned_data["confirm_password"]) #对confirm_password也进行加密
        if confirm !=pwd: #比较的是加密后的密码
            raise ValidationError("密码不一致！")
        return confirm   # return 什么，则confirm_password这个字段的值就保存什么
def admin_edit(request,nid):
    row_obj=models.Admin.objects.filter(id=nid).first()
    print(row_obj)
    #如果用户胡乱输入或者该条信息已经被其它用户删除，可能导致返回none
    if not row_obj:
        # return redirect ('/admin/list')
        return render(request, 'error.html',{'msg':'数据不存在！'})
    if request.method=="GET":        
        form=AdminEditModelForm(instance=row_obj)
        return render(request,"admin_edit.html",{"form":form})
    #處理POST數據：    
    form = AdminEditModelForm(data=request.POST,instance=row_obj) 
    if form.is_valid():
        form.save()
        return redirect ("/admin/list")
    else:
        # print(form.errors)
        return render (request, "admin_edit.html",{"form":form})
def admin_delete(request):
    nid=request.GET.get('nid')
    models.Admin.objects.filter(id=nid).delete()
    return redirect("/admin/list/")
#生成登录图形验证码: 打开登录界面，就会访问网址执行下面的函数，返回图片，存储code_string到Session中，然后再等待用户输入账号并登录
from app01.utils.code import check_code
from io import BytesIO
def image_code(request):
    img,code_string = check_code()  #调用验证码生成的函数
    print(code_string)
    request.session['image_code'] = code_string  #验证码存入session
    request.session.set_expiry(60)  #设置60秒过期

    stream = BytesIO()
    img.save(stream,'png')
    return HttpResponse(stream.getvalue())
#登录
#用ModelForm实现login,login后要用Admin表格进行校验
class LoginModelForm(forms.ModelForm):
    class Meta:        
        model=models.Admin
        fields=["username","password"]   
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}
#用Form实现登录
class LoginForm(forms.Form):
    username=forms.CharField(
        label="用户名",   
        # required=True, 必填项，但是不用写，默认如此
        widget=forms.TextInput(attrs={"class":"form-control","placeholder":"username"})   
    ) 
    password=forms.CharField(
        label="密码",           
        #render_value=True 可以让输错的密码，提示的同时，并不会被清空
        widget=forms.PasswordInput(attrs={"class":"form-control","placeholder":"password"},render_value=True)  
    )    
    code=forms.CharField(
        label="验证码",         
        widget=forms.TextInput(attrs={"class":"form-control","placeholder":"请输入右侧验证码"})  
    )    
    #如果字段多，也可以直接把 def __init__(self,*args,**kwargs):复制过来使用
    #定义一个钩子函数，当用户输入密码后可以加密成md5返回,再在函数中进行比较
    def clean_password(self):
        pwd = self.cleaned_data.get("password")
        return md5(pwd)

def login(request):
    if request.method=="GET":
        form=LoginForm()
        return render(request,'login.html',{'form':form})
    #POST提交用户登录信息
    form=LoginForm(data=request.POST)
     #此时得到的密码是明文，DB中是密文，所以要在Class中定义一个钩子函数进行转换。
    if form.is_valid():  #登录时，验证成功后并不是去存到数据库，而是要进一步和数据库数据进行比对。
         #如果不定义钩子函数，得到cleaned_data是一个字典{'username': 'lijun', 'password': '123'}
         #因为上面已经定义钩子函数，因此得到的字典将是：{'username': 'lijun', 'password': '5d6303297c38b56af267d64d64c84b7d'}
        print(form.cleaned_data) 
        #把获得的数据与DB中进行查询比对，如果查不到，则admin_obj将为None
        #admin_obj = models.Admin.objects.filter(username=form.cleaned_data['username'], password=form.cleaned_data['password']).first()
        #因为filter可以直接查询字典，因此下面是更简单的写法：form.cleaned_data就是字典

        #如果有图形验证码，则cleaned_data字典中后面又新增一个code数据
        user_input_code = form.cleaned_data.pop('code')  #pop相当于从cleaned_data字典中“剪切”掉code,以免影响后面的DB比较
        code = request.session.get('image_code',"")  #读取session中的code, 如果没有返回空字符串
        if code.upper() != user_input_code.upper():  #.upper()是都变成大写
            form.add_error("code","验证码错误")
            return render(request,'login.html',{'form':form})  #验证码错误直接返回

        admin_obj = models.Admin.objects.filter(**form.cleaned_data).first()
        if not admin_obj:
            #如果DB中没有找到输入的用户信息，则会返回登录界面，但是不会提示错误信息
            #我们可以人为主动地增加错误信息，它会显示在写的字段之下
            form.add_error("password","用户名或密码错误！")
            return render(request,"login.html",{'form':form})
        #密码验证正确：
        #下面这句可以完成：将id,name做为字典进行保存，加密后保存到session中，同时生成一个字符串分别保存到session和用户浏览器的cookie中
        request.session["info"]={'id':admin_obj.id,'name':admin_obj.username}
        #本来session有自己默认的过期时间，但是因为之前存入验证码时设了60秒过期（整个session过期），所以需重新设一下
        request.session.set_expiry(60*60*24*7)  
        return redirect("/admin/list/")
        # return HttpResponse ("提交成功！")
    return render(request,"login.html",{'form':form})


def logout(request):
    request.session.clear()
    return redirect('/login/')




import json
from django.http import JsonResponse
@csrf_exempt
def task_ajax(request):
    print(request.GET)  #用GET POST均可，但是用POST必须要在前面加@csrf_exemt免除校验
    print(request.POST)
    data_dict = {"status":True, 'data':[11,22,33,44]}
    json_string = json.dumps(data_dict)    
    return HttpResponse(json_string)
    #上面两行可以简化为下面这行，但是事项要导入JsonResponse
    # return JsonResponse(data_dict)

 
class TaskModelForm(forms.ModelForm):
    class Meta:        
        model=models.Task
        fields=["level","title","detail","user"]   
        #detail字段在models中定义的是Textfield, 则生成前端表格时自动按Textarea定义，如果不想要那么大空间，还是可以人为重新定义的，如下：
        widgets = {
            "detail":forms.TextInput,
        }
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}
def task_list(request): 
    #获取数据库已有数据进行显示 
    queryset = models.Task.objects.all().order_by('-id')
    #通过Modelform传输form到前端生成输入表格 
    form=TaskModelForm() 
        #------添加分页在视图函数中添加：   
    per_page = 8     # 每页显示数量    
    paginator = Paginator(queryset, per_page)    # 创建Paginator对象    
    page_number = request.GET.get('page', 1)    # 获取当前页码（从GET参数获取，默认第1页）
    try:       
        queryset = paginator.page(page_number)   # 获取当前页对象
    except PageNotAnInteger:       
        queryset = paginator.page(1)  # 如果页码不是整数，返回第一页
    except EmptyPage:       
        queryset = paginator.page(paginator.num_pages)  # 如果页码超出范围，返回最后一页
    context={
        "form":form,
        "queryset":queryset,
        'paginator': paginator
    }
    return render (request,"task_list.html",context)   

@csrf_exempt
def task_add(request):
    print(request.POST) 
    form = TaskModelForm(data=request.POST)  
    if form.is_valid():
        form.save()
        data_dict = {"status":True} 
        return HttpResponse(json.dumps(data_dict) )
    #如果校验失败
    data_dict={"status":False,'error':form.errors}
    return HttpResponse(json.dumps(data_dict,ensure_ascii=False))

#订单管理
class OrderModelForm(forms.ModelForm):
    class Meta:        
        model=models.Order
        # fields="__all__"
        exclude = ["oid","admin"]
        # fields=["level","title","detail","user"]  
    def __init__(self,*args,**kwargs):
        super().__init__(*args,**kwargs)
        for name,field in self.fields.items():
            field.widget.attrs = {"class":"form-control", "placeholder":field.label}
def order_list(request):
    queryset = models.Order.objects.all().order_by('-id')
    #通过Modelform传输form到前端生成输入表格 
    form=OrderModelForm() 
        #------添加分页在视图函数中添加：   
    per_page = 8     # 每页显示数量    
    paginator = Paginator(queryset, per_page)    # 创建Paginator对象    
    page_number = request.GET.get('page', 1)    # 获取当前页码（从GET参数获取，默认第1页）
    try:       
        queryset = paginator.page(page_number)   # 获取当前页对象
    except PageNotAnInteger:       
        queryset = paginator.page(1)  # 如果页码不是整数，返回第一页
    except EmptyPage:       
        queryset = paginator.page(paginator.num_pages)  # 如果页码超出范围，返回最后一页
    context={
        "form":form,
        "queryset":queryset,
        'paginator': paginator
    }
    return render (request,"order_list.html",context)  
 

@csrf_exempt
def order_add(request):
    form = OrderModelForm(data=request.POST)
    if form.is_valid():
        #oid字段没有让用户输入，而是动态生成，随着输入数据同时保存进DB        
        form.instance.oid = datetime.now().strftime("%Y%m%d%H%M%S") + str(random.randint(1000,9999))
        #管理员id也不让用户输入，而是自动获取当前登录人员信息
        form.instance.admin_id = request.session["info"]["id"]
        form.save()
        data_dict = {"status":True} 
        return HttpResponse(json.dumps(data_dict) )
    #如果校验失败
    data_dict={"status":False,'error':form.errors}
    return HttpResponse(json.dumps(data_dict,ensure_ascii=False))

def order_delete(request):
    #先获取通过get传过来的uid
    uid = request.GET.get('uid')
    exists = models.Order.objects.filter(id=uid).exists()
    if not exists:  #不做判断也可以，直接删，不存在的情况应该是比较少的
        return JsonResponse({"status":False, 'error':"数据不存在"})
    models.Order.objects.filter(id=uid).delete()
    return JsonResponse({"status":True})


def order_edit(request):  
    uid=request.GET.get('uid')
    # row_obj=models.Order.objects.filter(id=uid).first()
    # if not row_obj:
    #     return JsonResponse({"status":False, 'error':"数据不存在"})
    # result = {
    #     "status":True,
    #     "data":{
    #         "title":row_obj.title,
    #         "price":row_obj.price,
    #         "status":row_obj.status,
    #     }
    # }
    # return JsonResponse(result)

    row_dict=models.Order.objects.filter(id=uid).values("title","price","status").first()
    if not row_dict:
        return JsonResponse({"status":False, 'error':"数据不存在"})
    result = {
        "status":True,
        "data":row_dict        
    }
    return JsonResponse(result)

@csrf_exempt
def edit_confirm(request):  #这一个函数里，uid是通过GET发过来的，表单数据是通过post发来的
    uid=request.GET.get('uid')
    #通过行id查DB得到该行对象
    row_obj=models.Order.objects.filter(id=uid).first() 
    if not row_obj:
        return JsonResponse({"status":False,'tips':"数据不存在"})
    #如果数据库中存在该条数据：则接收post传来的数据，并叠加上刚刚通过id查到的该行数据
    form = OrderModelForm(data=request.POST, instance=row_obj)
    if form.is_valid():
        form.save()
        return JsonResponse({"status":True})
    #如果校验失败
    return JsonResponse({"status":False,'error':form.errors})

    #本函数，可以传给前端一种True和两种False，True代表save成功，False还得再判断一下,看看数据是tips,还是error
    #False时，如果是tips,则简单alert, 反之，则要循序显示每个输入框的error内容

def chart_list(request):
    return render(request, "chart_list.html")

def chart_bar(request):
    # 从数据库中获取柱状图所需数据
    legend = ["李军","武沛齐"]
    series_list = [
        {
            "name":'李军',
            "type":'bar',
            "data":[15,20,16,16,10,20]
        },
        {
            "name":'武沛齐',
            "type":'bar',
            "data":[16,26,26,16,20,24]
        }
    ]
    x_axis = ['1月','2月','3月','4月','5月','6月']

    result = {
        "status":True,
        "data":{
            'legend':legend,
            'series_list':series_list,
            'x_axis':x_axis,
        }
    }
    return JsonResponse(result)

def chart_pie(request):
    # 从数据库中获取饼图所需数据
    db_data_list = [
        { "value": 1048, "name": 'IT部门' },
        { "value": 735, "name": '运营部' },
        { "value": 580, "name": '销售部' },
        { "value": 484, "name": '新媒体' },
        { "value": 100, "name": '实验室' }
      ]

    result = {
        "status":True,
        "data":db_data_list
    }
    return JsonResponse(result)

def chart_line(request):
    # 从数据库中获取图所需数据
    weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

    production_data = [150, 230, 224, 218, 135, 147, 260]

    result = {
        "status":True,
        "data":{
            'weekdays':weekdays,
            'production_data':production_data,
        }
    }
    return JsonResponse(result)